/* <orly/sabot/match_prefix_type.test.cc>

   Unit test for <orly/sabot/match_prefix_type.h>.

   Copyright 2010-2014 OrlyAtomics, Inc.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

     http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License. */

#include <orly/sabot/match_prefix_type.h>

#include <sstream>
#include <string>

#include <orly/native/all.h>
#include <orly/native/point.h>
#include <test/kit.h>

using namespace std;
using namespace Base;
using namespace Orly;
using namespace Orly::Native;
using namespace Orly::Sabot;

template <typename TLhs, typename TRhs>
TMatchResult MatchTypes() {
  void *lhs_type_alloc = alloca(Sabot::Type::GetMaxTypeSize() * 2);
  void *rhs_type_alloc = reinterpret_cast<uint8_t *>(lhs_type_alloc) + Sabot::Type::GetMaxTypeSize();
  return MatchPrefixType(*Sabot::Type::TAny::TWrapper(Native::Type::For<TLhs>::GetType(lhs_type_alloc)),
                         *Sabot::Type::TAny::TWrapper(Native::Type::For<TRhs>::GetType(rhs_type_alloc)));
}

FIXTURE(Typical) {
  EXPECT_TRUE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<int8_t>>()));
  EXPECT_TRUE(IsUnifies(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, int8_t>>()));
  EXPECT_TRUE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t>>()));
  EXPECT_TRUE(IsNoMatch(MatchTypes<tuple<int8_t, int8_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<int8_t>, tuple<int8_t, int8_t>>()));
}

FIXTURE(Int8) {
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t>, tuple<tuple<bool>>>()));

  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<int8_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t>, tuple<tuple<bool>>>()));
}

FIXTURE(Int16) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int16_t>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<int16_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int16_t>, tuple<tuple<bool>>>()));
}

FIXTURE(Int32) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<int32_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t>, tuple<tuple<bool>>>()));
}

FIXTURE(Int64) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int64_t>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<int64_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int64_t>, tuple<tuple<bool>>>()));
}

FIXTURE(UInt8) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint8_t>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint8_t>, tuple<tuple<bool>>>()));
}

FIXTURE(UInt16) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint16_t>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint16_t>, tuple<tuple<bool>>>()));
}

FIXTURE(UInt32) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint32_t>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint32_t>, tuple<tuple<bool>>>()));
}

FIXTURE(UInt64) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<uint64_t>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<uint64_t>, tuple<tuple<bool>>>()));
}

FIXTURE(Bool) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<bool>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<bool>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<bool>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<bool>, tuple<tuple<bool>>>()));
}

FIXTURE(Char) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<bool>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<char>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<char>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<bool>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<char>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<char>, tuple<tuple<bool>>>()));
}

FIXTURE(Float) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<char>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<float>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<float>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<char>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<float>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<float>, tuple<tuple<bool>>>()));
}

FIXTURE(Double) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<float>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<double>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<double>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<float>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<double>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<double>, tuple<tuple<bool>>>()));
}

FIXTURE(Duration) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<double>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdDuration>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<double>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdDuration>, tuple<tuple<bool>>>()));
}

FIXTURE(Timepoint) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TStdTimePoint>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TStdTimePoint>, tuple<tuple<bool>>>()));
}

FIXTURE(Uuid) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TUuid>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TUuid>, tuple<tuple<bool>>>()));
}

FIXTURE(Blob) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TUuid>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TBlob>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TUuid>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TBlob>, tuple<tuple<bool>>>()));
}

FIXTURE(String) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TBlob>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<string>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<string>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TBlob>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<string>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<string>, tuple<tuple<bool>>>()));
}

FIXTURE(Tombstone) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<string>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TTombstone>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<string>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TTombstone>, tuple<tuple<bool>>>()));
}

FIXTURE(Void) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<void>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<void>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<void>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<void>, tuple<tuple<bool>>>()));
}

FIXTURE(Desc) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<void>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TDesc<bool>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<void>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TDesc<bool>>, tuple<tuple<bool>>>()));
}

FIXTURE(Opt) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TOpt<bool>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TOpt<bool>>, tuple<tuple<bool>>>()));
}

FIXTURE(Set) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<set<bool>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<set<bool>>, tuple<tuple<bool>>>()));
}

FIXTURE(Vector) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<vector<bool>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<vector<bool>>, tuple<tuple<bool>>>()));
}

FIXTURE(Map) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<map<bool, char>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<map<bool, char>>, tuple<tuple<bool>>>()));
}

FIXTURE(Point) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<TPoint>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<TPoint>, tuple<TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<TPoint>, tuple<tuple<bool>>>()));
}

FIXTURE(Tuple) {
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<tuple<bool>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<TPoint>>()));
  EXPECT_FALSE(IsNoMatch(MatchTypes<tuple<tuple<bool>>, tuple<tuple<bool>>>()));
}

FIXTURE(Free) {
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<int16_t>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<int32_t>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<int64_t>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<uint8_t>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<uint16_t>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<uint32_t>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<uint64_t>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<bool>>, tuple<bool>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<char>>, tuple<char>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<float>>, tuple<float>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<double>>, tuple<double>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TStdDuration>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TStdTimePoint>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TUuid>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TBlob>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<string>>, tuple<string>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TTombstone>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<void>>, tuple<void>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TDesc<bool>>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TOpt<bool>>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<set<bool>>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<vector<bool>>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<map<bool, char>>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<TPoint>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<tuple<bool>>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<int8_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<int16_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<int32_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<int64_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<uint8_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<uint16_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<uint32_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<uint64_t>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<bool>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<char>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<float>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<double>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TStdDuration>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TStdTimePoint>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TUuid>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TBlob>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<string>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TTombstone>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<void>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TDesc<bool>>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TOpt<bool>>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<set<bool>>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<vector<bool>>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<map<bool, char>>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<TPoint>>()));
  EXPECT_FALSE(IsUnifies(MatchTypes<tuple<TFree<int8_t>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<int8_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<int16_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<int32_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<int64_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<uint8_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<uint16_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<uint32_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<uint64_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<bool>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<char>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<float>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<double>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TStdDuration>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TStdTimePoint>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TUuid>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TBlob>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<string>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TTombstone>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<void>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TDesc<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TOpt<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<set<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<vector<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<map<bool, char>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<TPoint>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<TFree<int8_t>>, tuple<tuple<bool>>>()));

  EXPECT_TRUE (IsUnifies(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, int8_t>>()));

  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, int8_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, int16_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, int32_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, int64_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, uint8_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, uint16_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, uint32_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, uint64_t>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, bool>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, char>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, float>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, double>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TStdDuration>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TStdTimePoint>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TUuid>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TBlob>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, string>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TTombstone>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, void>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TDesc<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TOpt<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, set<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, vector<bool>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, map<bool, char>>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, TPoint>>()));
  EXPECT_TRUE (IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int8_t, tuple<bool>>>()));

  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int8_t, TFree<int8_t>>, tuple<int32_t, tuple<bool>>>()));

  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint8_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint16_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint32_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint64_t>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, bool>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, char>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, float>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, double>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TStdDuration>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TStdTimePoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TUuid>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TBlob>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, string>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TTombstone>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, void>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TDesc<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TOpt<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, set<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, vector<bool>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, map<bool, char>>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TPoint>>()));
  EXPECT_FALSE(IsPrefixMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, tuple<bool>>>()));

  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, int64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint8_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint16_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint32_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, uint64_t>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, bool>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, char>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, float>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, double>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TStdDuration>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TStdTimePoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TUuid>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TBlob>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, string>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TTombstone>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, void>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TDesc<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TOpt<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, set<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, vector<bool>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, map<bool, char>>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, TPoint>>()));
  EXPECT_TRUE (IsNoMatch(MatchTypes<tuple<int32_t, TFree<int8_t>>, tuple<int8_t, tuple<bool>>>()));
}